
// MIT License
// 
// Copyright (c) 2009-2017 Luca Piccioni
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
// 
// This file is automatically generated

#pragma warning disable 649, 1572, 1573

// ReSharper disable RedundantUsingDirective
using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;

using Khronos;

// ReSharper disable CheckNamespace
// ReSharper disable InconsistentNaming
// ReSharper disable JoinDeclarationAndInitializer

namespace OpenGL
{
	public partial class Gl
	{
		/// <summary>
		/// [GL] Value of GL_MAX_VERTEX_STREAMS_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int MAX_VERTEX_STREAMS_ATI = 0x876B;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM0_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM0_ATI = 0x876C;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM1_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM1_ATI = 0x876D;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM2_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM2_ATI = 0x876E;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM3_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM3_ATI = 0x876F;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM4_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM4_ATI = 0x8770;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM5_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM5_ATI = 0x8771;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM6_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM6_ATI = 0x8772;

		/// <summary>
		/// [GL] Value of GL_VERTEX_STREAM7_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_STREAM7_ATI = 0x8773;

		/// <summary>
		/// [GL] Value of GL_VERTEX_SOURCE_ATI symbol.
		/// </summary>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public const int VERTEX_SOURCE_ATI = 0x8774;

		/// <summary>
		/// [GL] glVertexStream1sATI: Binding for glVertexStream1sATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:short"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, short x)
		{
			Debug.Assert(Delegates.pglVertexStream1sATI != null, "pglVertexStream1sATI not implemented");
			Delegates.pglVertexStream1sATI(stream, x);
			LogCommand("glVertexStream1sATI", null, stream, x			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1svATI: Binding for glVertexStream1svATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, short[] coords)
		{
			Debug.Assert(coords.Length >= 1);
			unsafe {
				fixed (short* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream1svATI != null, "pglVertexStream1svATI not implemented");
					Delegates.pglVertexStream1svATI(stream, p_coords);
					LogCommand("glVertexStream1svATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1iATI: Binding for glVertexStream1iATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, int x)
		{
			Debug.Assert(Delegates.pglVertexStream1iATI != null, "pglVertexStream1iATI not implemented");
			Delegates.pglVertexStream1iATI(stream, x);
			LogCommand("glVertexStream1iATI", null, stream, x			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1ivATI: Binding for glVertexStream1ivATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:int[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, int[] coords)
		{
			Debug.Assert(coords.Length >= 1);
			unsafe {
				fixed (int* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream1ivATI != null, "pglVertexStream1ivATI not implemented");
					Delegates.pglVertexStream1ivATI(stream, p_coords);
					LogCommand("glVertexStream1ivATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1fATI: Binding for glVertexStream1fATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, float x)
		{
			Debug.Assert(Delegates.pglVertexStream1fATI != null, "pglVertexStream1fATI not implemented");
			Delegates.pglVertexStream1fATI(stream, x);
			LogCommand("glVertexStream1fATI", null, stream, x			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1fvATI: Binding for glVertexStream1fvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, float[] coords)
		{
			Debug.Assert(coords.Length >= 1);
			unsafe {
				fixed (float* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream1fvATI != null, "pglVertexStream1fvATI not implemented");
					Delegates.pglVertexStream1fvATI(stream, p_coords);
					LogCommand("glVertexStream1fvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1dATI: Binding for glVertexStream1dATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:double"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, double x)
		{
			Debug.Assert(Delegates.pglVertexStream1dATI != null, "pglVertexStream1dATI not implemented");
			Delegates.pglVertexStream1dATI(stream, x);
			LogCommand("glVertexStream1dATI", null, stream, x			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream1dvATI: Binding for glVertexStream1dvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream1ATI(int stream, double[] coords)
		{
			Debug.Assert(coords.Length >= 1);
			unsafe {
				fixed (double* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream1dvATI != null, "pglVertexStream1dvATI not implemented");
					Delegates.pglVertexStream1dvATI(stream, p_coords);
					LogCommand("glVertexStream1dvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2sATI: Binding for glVertexStream2sATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:short"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, short x, short y)
		{
			Debug.Assert(Delegates.pglVertexStream2sATI != null, "pglVertexStream2sATI not implemented");
			Delegates.pglVertexStream2sATI(stream, x, y);
			LogCommand("glVertexStream2sATI", null, stream, x, y			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2svATI: Binding for glVertexStream2svATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, short[] coords)
		{
			Debug.Assert(coords.Length >= 2);
			unsafe {
				fixed (short* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream2svATI != null, "pglVertexStream2svATI not implemented");
					Delegates.pglVertexStream2svATI(stream, p_coords);
					LogCommand("glVertexStream2svATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2iATI: Binding for glVertexStream2iATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, int x, int y)
		{
			Debug.Assert(Delegates.pglVertexStream2iATI != null, "pglVertexStream2iATI not implemented");
			Delegates.pglVertexStream2iATI(stream, x, y);
			LogCommand("glVertexStream2iATI", null, stream, x, y			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2ivATI: Binding for glVertexStream2ivATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:int[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, int[] coords)
		{
			Debug.Assert(coords.Length >= 2);
			unsafe {
				fixed (int* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream2ivATI != null, "pglVertexStream2ivATI not implemented");
					Delegates.pglVertexStream2ivATI(stream, p_coords);
					LogCommand("glVertexStream2ivATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2fATI: Binding for glVertexStream2fATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, float x, float y)
		{
			Debug.Assert(Delegates.pglVertexStream2fATI != null, "pglVertexStream2fATI not implemented");
			Delegates.pglVertexStream2fATI(stream, x, y);
			LogCommand("glVertexStream2fATI", null, stream, x, y			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2fvATI: Binding for glVertexStream2fvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, float[] coords)
		{
			Debug.Assert(coords.Length >= 2);
			unsafe {
				fixed (float* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream2fvATI != null, "pglVertexStream2fvATI not implemented");
					Delegates.pglVertexStream2fvATI(stream, p_coords);
					LogCommand("glVertexStream2fvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2dATI: Binding for glVertexStream2dATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:double"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, double x, double y)
		{
			Debug.Assert(Delegates.pglVertexStream2dATI != null, "pglVertexStream2dATI not implemented");
			Delegates.pglVertexStream2dATI(stream, x, y);
			LogCommand("glVertexStream2dATI", null, stream, x, y			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream2dvATI: Binding for glVertexStream2dvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream2ATI(int stream, double[] coords)
		{
			Debug.Assert(coords.Length >= 2);
			unsafe {
				fixed (double* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream2dvATI != null, "pglVertexStream2dvATI not implemented");
					Delegates.pglVertexStream2dvATI(stream, p_coords);
					LogCommand("glVertexStream2dvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3sATI: Binding for glVertexStream3sATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:short"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, short x, short y, short z)
		{
			Debug.Assert(Delegates.pglVertexStream3sATI != null, "pglVertexStream3sATI not implemented");
			Delegates.pglVertexStream3sATI(stream, x, y, z);
			LogCommand("glVertexStream3sATI", null, stream, x, y, z			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3svATI: Binding for glVertexStream3svATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, short[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (short* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream3svATI != null, "pglVertexStream3svATI not implemented");
					Delegates.pglVertexStream3svATI(stream, p_coords);
					LogCommand("glVertexStream3svATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3iATI: Binding for glVertexStream3iATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, int x, int y, int z)
		{
			Debug.Assert(Delegates.pglVertexStream3iATI != null, "pglVertexStream3iATI not implemented");
			Delegates.pglVertexStream3iATI(stream, x, y, z);
			LogCommand("glVertexStream3iATI", null, stream, x, y, z			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3ivATI: Binding for glVertexStream3ivATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:int[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, int[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (int* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream3ivATI != null, "pglVertexStream3ivATI not implemented");
					Delegates.pglVertexStream3ivATI(stream, p_coords);
					LogCommand("glVertexStream3ivATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3fATI: Binding for glVertexStream3fATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, float x, float y, float z)
		{
			Debug.Assert(Delegates.pglVertexStream3fATI != null, "pglVertexStream3fATI not implemented");
			Delegates.pglVertexStream3fATI(stream, x, y, z);
			LogCommand("glVertexStream3fATI", null, stream, x, y, z			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3fvATI: Binding for glVertexStream3fvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, float[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (float* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream3fvATI != null, "pglVertexStream3fvATI not implemented");
					Delegates.pglVertexStream3fvATI(stream, p_coords);
					LogCommand("glVertexStream3fvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3dATI: Binding for glVertexStream3dATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:double"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, double x, double y, double z)
		{
			Debug.Assert(Delegates.pglVertexStream3dATI != null, "pglVertexStream3dATI not implemented");
			Delegates.pglVertexStream3dATI(stream, x, y, z);
			LogCommand("glVertexStream3dATI", null, stream, x, y, z			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream3dvATI: Binding for glVertexStream3dvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream3ATI(int stream, double[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (double* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream3dvATI != null, "pglVertexStream3dvATI not implemented");
					Delegates.pglVertexStream3dvATI(stream, p_coords);
					LogCommand("glVertexStream3dvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4sATI: Binding for glVertexStream4sATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:short"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, short x, short y, short z, short w)
		{
			Debug.Assert(Delegates.pglVertexStream4sATI != null, "pglVertexStream4sATI not implemented");
			Delegates.pglVertexStream4sATI(stream, x, y, z, w);
			LogCommand("glVertexStream4sATI", null, stream, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4svATI: Binding for glVertexStream4svATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, short[] coords)
		{
			Debug.Assert(coords.Length >= 4);
			unsafe {
				fixed (short* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream4svATI != null, "pglVertexStream4svATI not implemented");
					Delegates.pglVertexStream4svATI(stream, p_coords);
					LogCommand("glVertexStream4svATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4iATI: Binding for glVertexStream4iATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, int x, int y, int z, int w)
		{
			Debug.Assert(Delegates.pglVertexStream4iATI != null, "pglVertexStream4iATI not implemented");
			Delegates.pglVertexStream4iATI(stream, x, y, z, w);
			LogCommand("glVertexStream4iATI", null, stream, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4ivATI: Binding for glVertexStream4ivATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:int[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, int[] coords)
		{
			Debug.Assert(coords.Length >= 4);
			unsafe {
				fixed (int* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream4ivATI != null, "pglVertexStream4ivATI not implemented");
					Delegates.pglVertexStream4ivATI(stream, p_coords);
					LogCommand("glVertexStream4ivATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4fATI: Binding for glVertexStream4fATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, float x, float y, float z, float w)
		{
			Debug.Assert(Delegates.pglVertexStream4fATI != null, "pglVertexStream4fATI not implemented");
			Delegates.pglVertexStream4fATI(stream, x, y, z, w);
			LogCommand("glVertexStream4fATI", null, stream, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4fvATI: Binding for glVertexStream4fvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, float[] coords)
		{
			Debug.Assert(coords.Length >= 4);
			unsafe {
				fixed (float* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream4fvATI != null, "pglVertexStream4fvATI not implemented");
					Delegates.pglVertexStream4fvATI(stream, p_coords);
					LogCommand("glVertexStream4fvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4dATI: Binding for glVertexStream4dATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="x">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="y">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="z">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="w">
		/// A <see cref="T:double"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, double x, double y, double z, double w)
		{
			Debug.Assert(Delegates.pglVertexStream4dATI != null, "pglVertexStream4dATI not implemented");
			Delegates.pglVertexStream4dATI(stream, x, y, z, w);
			LogCommand("glVertexStream4dATI", null, stream, x, y, z, w			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexStream4dvATI: Binding for glVertexStream4dvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexStream4ATI(int stream, double[] coords)
		{
			Debug.Assert(coords.Length >= 4);
			unsafe {
				fixed (double* p_coords = coords)
				{
					Debug.Assert(Delegates.pglVertexStream4dvATI != null, "pglVertexStream4dvATI not implemented");
					Delegates.pglVertexStream4dvATI(stream, p_coords);
					LogCommand("glVertexStream4dvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3bATI: Binding for glNormalStream3bATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:sbyte"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:sbyte"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:sbyte"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, sbyte nx, sbyte ny, sbyte nz)
		{
			Debug.Assert(Delegates.pglNormalStream3bATI != null, "pglNormalStream3bATI not implemented");
			Delegates.pglNormalStream3bATI(stream, nx, ny, nz);
			LogCommand("glNormalStream3bATI", null, stream, nx, ny, nz			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3bvATI: Binding for glNormalStream3bvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:sbyte[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, sbyte[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (sbyte* p_coords = coords)
				{
					Debug.Assert(Delegates.pglNormalStream3bvATI != null, "pglNormalStream3bvATI not implemented");
					Delegates.pglNormalStream3bvATI(stream, p_coords);
					LogCommand("glNormalStream3bvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3sATI: Binding for glNormalStream3sATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:short"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:short"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, short nx, short ny, short nz)
		{
			Debug.Assert(Delegates.pglNormalStream3sATI != null, "pglNormalStream3sATI not implemented");
			Delegates.pglNormalStream3sATI(stream, nx, ny, nz);
			LogCommand("glNormalStream3sATI", null, stream, nx, ny, nz			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3svATI: Binding for glNormalStream3svATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:short[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, short[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (short* p_coords = coords)
				{
					Debug.Assert(Delegates.pglNormalStream3svATI != null, "pglNormalStream3svATI not implemented");
					Delegates.pglNormalStream3svATI(stream, p_coords);
					LogCommand("glNormalStream3svATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3iATI: Binding for glNormalStream3iATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, int nx, int ny, int nz)
		{
			Debug.Assert(Delegates.pglNormalStream3iATI != null, "pglNormalStream3iATI not implemented");
			Delegates.pglNormalStream3iATI(stream, nx, ny, nz);
			LogCommand("glNormalStream3iATI", null, stream, nx, ny, nz			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3ivATI: Binding for glNormalStream3ivATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:int[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, int[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (int* p_coords = coords)
				{
					Debug.Assert(Delegates.pglNormalStream3ivATI != null, "pglNormalStream3ivATI not implemented");
					Delegates.pglNormalStream3ivATI(stream, p_coords);
					LogCommand("glNormalStream3ivATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3fATI: Binding for glNormalStream3fATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:float"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, float nx, float ny, float nz)
		{
			Debug.Assert(Delegates.pglNormalStream3fATI != null, "pglNormalStream3fATI not implemented");
			Delegates.pglNormalStream3fATI(stream, nx, ny, nz);
			LogCommand("glNormalStream3fATI", null, stream, nx, ny, nz			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3fvATI: Binding for glNormalStream3fvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:float[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, float[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (float* p_coords = coords)
				{
					Debug.Assert(Delegates.pglNormalStream3fvATI != null, "pglNormalStream3fvATI not implemented");
					Delegates.pglNormalStream3fvATI(stream, p_coords);
					LogCommand("glNormalStream3fvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3dATI: Binding for glNormalStream3dATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="nx">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="ny">
		/// A <see cref="T:double"/>.
		/// </param>
		/// <param name="nz">
		/// A <see cref="T:double"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, double nx, double ny, double nz)
		{
			Debug.Assert(Delegates.pglNormalStream3dATI != null, "pglNormalStream3dATI not implemented");
			Delegates.pglNormalStream3dATI(stream, nx, ny, nz);
			LogCommand("glNormalStream3dATI", null, stream, nx, ny, nz			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glNormalStream3dvATI: Binding for glNormalStream3dvATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="coords">
		/// A <see cref="T:double[]"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void NormalStream3ATI(int stream, double[] coords)
		{
			Debug.Assert(coords.Length >= 3);
			unsafe {
				fixed (double* p_coords = coords)
				{
					Debug.Assert(Delegates.pglNormalStream3dvATI != null, "pglNormalStream3dvATI not implemented");
					Delegates.pglNormalStream3dvATI(stream, p_coords);
					LogCommand("glNormalStream3dvATI", null, stream, coords					);
				}
			}
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glClientActiveVertexStreamATI: Binding for glClientActiveVertexStreamATI.
		/// </summary>
		/// <param name="stream">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void ClientActiveVertexStreamATI(int stream)
		{
			Debug.Assert(Delegates.pglClientActiveVertexStreamATI != null, "pglClientActiveVertexStreamATI not implemented");
			Delegates.pglClientActiveVertexStreamATI(stream);
			LogCommand("glClientActiveVertexStreamATI", null, stream			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexBlendEnviATI: Binding for glVertexBlendEnviATI.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:int"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexBlendEnvATI(int pname, int param)
		{
			Debug.Assert(Delegates.pglVertexBlendEnviATI != null, "pglVertexBlendEnviATI not implemented");
			Delegates.pglVertexBlendEnviATI(pname, param);
			LogCommand("glVertexBlendEnviATI", null, pname, param			);
			DebugCheckErrors(null);
		}

		/// <summary>
		/// [GL] glVertexBlendEnvfATI: Binding for glVertexBlendEnvfATI.
		/// </summary>
		/// <param name="pname">
		/// A <see cref="T:int"/>.
		/// </param>
		/// <param name="param">
		/// A <see cref="T:float"/>.
		/// </param>
		[RequiredByFeature("GL_ATI_vertex_streams")]
		public static void VertexBlendEnvATI(int pname, float param)
		{
			Debug.Assert(Delegates.pglVertexBlendEnvfATI != null, "pglVertexBlendEnvfATI not implemented");
			Delegates.pglVertexBlendEnvfATI(pname, param);
			LogCommand("glVertexBlendEnvfATI", null, pname, param			);
			DebugCheckErrors(null);
		}

		internal static unsafe partial class Delegates
		{
			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1sATI(int stream, short x);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1sATI pglVertexStream1sATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1svATI(int stream, short* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1svATI pglVertexStream1svATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1iATI(int stream, int x);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1iATI pglVertexStream1iATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1ivATI(int stream, int* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1ivATI pglVertexStream1ivATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1fATI(int stream, float x);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1fATI pglVertexStream1fATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1fvATI(int stream, float* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1fvATI pglVertexStream1fvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1dATI(int stream, double x);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1dATI pglVertexStream1dATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream1dvATI(int stream, double* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream1dvATI pglVertexStream1dvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2sATI(int stream, short x, short y);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2sATI pglVertexStream2sATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2svATI(int stream, short* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2svATI pglVertexStream2svATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2iATI(int stream, int x, int y);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2iATI pglVertexStream2iATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2ivATI(int stream, int* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2ivATI pglVertexStream2ivATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2fATI(int stream, float x, float y);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2fATI pglVertexStream2fATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2fvATI(int stream, float* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2fvATI pglVertexStream2fvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2dATI(int stream, double x, double y);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2dATI pglVertexStream2dATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream2dvATI(int stream, double* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream2dvATI pglVertexStream2dvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3sATI(int stream, short x, short y, short z);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3sATI pglVertexStream3sATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3svATI(int stream, short* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3svATI pglVertexStream3svATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3iATI(int stream, int x, int y, int z);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3iATI pglVertexStream3iATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3ivATI(int stream, int* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3ivATI pglVertexStream3ivATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3fATI(int stream, float x, float y, float z);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3fATI pglVertexStream3fATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3fvATI(int stream, float* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3fvATI pglVertexStream3fvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3dATI(int stream, double x, double y, double z);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3dATI pglVertexStream3dATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream3dvATI(int stream, double* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream3dvATI pglVertexStream3dvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4sATI(int stream, short x, short y, short z, short w);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4sATI pglVertexStream4sATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4svATI(int stream, short* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4svATI pglVertexStream4svATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4iATI(int stream, int x, int y, int z, int w);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4iATI pglVertexStream4iATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4ivATI(int stream, int* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4ivATI pglVertexStream4ivATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4fATI(int stream, float x, float y, float z, float w);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4fATI pglVertexStream4fATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4fvATI(int stream, float* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4fvATI pglVertexStream4fvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4dATI(int stream, double x, double y, double z, double w);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4dATI pglVertexStream4dATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexStream4dvATI(int stream, double* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexStream4dvATI pglVertexStream4dvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3bATI(int stream, sbyte nx, sbyte ny, sbyte nz);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3bATI pglNormalStream3bATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3bvATI(int stream, sbyte* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3bvATI pglNormalStream3bvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3sATI(int stream, short nx, short ny, short nz);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3sATI pglNormalStream3sATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3svATI(int stream, short* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3svATI pglNormalStream3svATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3iATI(int stream, int nx, int ny, int nz);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3iATI pglNormalStream3iATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3ivATI(int stream, int* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3ivATI pglNormalStream3ivATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3fATI(int stream, float nx, float ny, float nz);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3fATI pglNormalStream3fATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3fvATI(int stream, float* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3fvATI pglNormalStream3fvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3dATI(int stream, double nx, double ny, double nz);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3dATI pglNormalStream3dATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glNormalStream3dvATI(int stream, double* coords);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glNormalStream3dvATI pglNormalStream3dvATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glClientActiveVertexStreamATI(int stream);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glClientActiveVertexStreamATI pglClientActiveVertexStreamATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexBlendEnviATI(int pname, int param);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexBlendEnviATI pglVertexBlendEnviATI;

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[SuppressUnmanagedCodeSecurity]
			internal delegate void glVertexBlendEnvfATI(int pname, float param);

			[RequiredByFeature("GL_ATI_vertex_streams")]
			[ThreadStatic]
			internal static glVertexBlendEnvfATI pglVertexBlendEnvfATI;

		}
	}

}
